Skip to main content

CRUD Operations

CRUD Operations: insertOne, find, updateOne, deleteOne.

1. Problem Statement​

Case Study: FastBite Food Delivery​

FastBite is building a scalable backend for managing restaurant menus and customer orders:

  • New dishes are added and removed daily as menus change.

  • Customers need to search for dishes by cuisine, price, or dietary tags.

  • Prices and availability change frequently—updates must be fast and reliable.

  • Orders and menu items must be deleted or archived when restaurants close or dishes are discontinued.

Sample Image

The challenge:
How do you ensure the system can efficiently create, read, update, and delete menu and order data, while maintaining data integrity and performance as the business grows?

2. Learning Objectives​

By the end of this tutorial, you will:

  • Understand the role and guarantees of CRUD operations in MongoDB.

  • Use insertOne to add new documents to a collection.

  • Use find with advanced queries, projections, and sorting to retrieve documents.

  • Use updateOne with operators to modify documents safely and atomically.

  • Use deleteOne to remove documents, understanding the importance of filters and atomicity.

  • Apply best practices for data modeling, error handling, and performance.

3. Concept Introduction with Analogy​

Analogy: The Restaurant Order Board​

  • insertOne: Like a chef pinning a new dish to the kitchen’s order board.

  • find: Scanning the board for all “Vegan” or “Under $10” dishes.

  • updateOne: The manager changes the price or marks a dish as “out of stock.”

  • deleteOne: Removing a discontinued dish from the board.

MongoDB’s CRUD operations are your digital tools for managing this ever-changing board—instantly, reliably, and at scale.

4. Technical Deep Dive​

A. MongoDB CRUD Basics​

  • Atomicity: Each operation is atomic at the document level.

  • Document Structure: Flexible schema allows nested fields (e.g., price.currency, price.value).

  • Indexes: Improve query performance (e.g., indexing category or price).

B. insertOne: Adding Products​

Purpose: Add a single document to a collection.

Syntax:

db.products.insertOne({  
  name: "Wireless Headphones",  
  category: "Electronics",  
  price: { value: 99.99, currency: "USD" },  
  stock: 50,  
  ratings: [4.5, 4.7, 4.8]  
});

Key Notes:

  • MongoDB auto-generates a unique _id (primary key) if not provided.

  • Returns an acknowledged: true and the inserted _id.

C. find: Querying Products​

Purpose: Retrieve documents matching criteria.

Syntax:

// Find all electronics in stock  
db.products.find({  
  category: "Electronics",  
  stock: { $gt: 0 }  
});  

// Projection: Include only name and price  
db.products.find(  
  { category: "Electronics" },  
  { name: 1, price: 1, _id: 0 }  
);  

// Sorting: Highest price first  
db.products.find().sort({ "price.value": -1 });

Operators:

  • Comparison: $eq, $gt, $lt, $in.

  • Logical: $and, $or, $not.

  • Array: $elemMatch, $size.

D. updateOne: Modifying Products​

Purpose: Update a single document matching a filter.

Syntax:

// Update stock quantity for a product  
db.products.updateOne(  
  { _id: ObjectId("...") },  
  { $set: { stock: 45 } }  
);  

// Increment stock by 10  
db.products.updateOne(  
  { name: "Wireless Headphones" },  
  { $inc: { stock: 10 } }  
);  

// Add a new field (e.g., discount)  
db.products.updateOne(  
  { _id: ObjectId("...") },  
  { $set: { "price.discount": 15 } }  
);

Key Notes:

  • Use $set, $inc, $push (for arrays) to avoid overwriting the entire document.

  • Always include a filter to prevent accidental updates.

E. deleteOne: Removing Products​

Purpose: Delete a single document matching a filter.

Syntax:

// Delete a discontinued product  
db.products.deleteOne({  
  _id: ObjectId("...")  
});  

// Delete by name (ensure uniqueness first)  
db.products.deleteOne({  
  name: "Outdated Model XYZ"  
});

Key Notes:

  • Use precise filters to avoid accidental deletions.

  • Consider archiving instead of deleting for historical data.

5. Step-by-Step Code Walkthrough​

A. Define the Product Schema​

// Sample product document

{  
  _id: ObjectId("665f4d7e8b3e6c1e24a7b3e1"),  
  name: "Smartwatch Pro",  
  category: "Wearables",  
  price: { value: 199.99, currency: "USD", discount: 20 },  
  stock: 25,  
  ratings: [4.6, 4.8],  
  tags: ["fitness", "bluetooth"]  
}

B. Insert a New Product​

db.products.insertOne({  
  name: "4K Smart TV",  
  category: "Electronics",  
  price: { value: 599.99, currency: "USD" },  
  stock: 10,  
  tags: ["television", "streaming"]  
});

Output:

{  
  acknowledged: true,  
  insertedId: ObjectId("665f4d7e8b3e6c1e24a7b3e2")  
}

C. Query Products​

// Find all TVs under $600  
db.products.find({  
  category: "Electronics",  
  "price.value": { $lt: 600 },  
  name: /TV/i  
});  

// Project name and price only  
db.products.find(  
  { category: "Electronics" },  
  { name: 1, "price.value": 1, _id: 0 }  
);

D. Update Product Stock​

// Reduce stock by 1 when purchased  
db.products.updateOne(  
  { _id: ObjectId("665f4d7e8b3e6c1e24a7b3e2") },  
  { $inc: { stock: -1 } }  
);  

// Add a "sale" tag  
db.products.updateOne(  
  { name: "4K Smart TV" },  
  { $push: { tags: "sale" } }  
);

E. Delete a Discontinued Product​

db.products.deleteOne({  
  name: "Legacy DVD Player"  
});

6. Interactive Challenge / Mini-Project​

Your Turn!

You’re managing FastBite’s menu database. Complete these tasks using MongoDB CRUD operations:

  1. Add a new vegan dish called “Tofu Buddha Bowl” (cuisine: “Asian”, price: $9.50, tags: [“vegan”, “gluten-free”], available: true).

  2. Find all available vegan dishes under $12, showing only their name and price.

  3. Update the price of “Tofu Buddha Bowl” to $10.00 and add a “popular” tag.

  4. Delete the dish “Old Special Soup” from the menu.

7. Common Pitfalls & Best Practices​

PitfallBest Practice
Using update without operatorsAlways use $set, $inc, etc., not raw objects
Broad delete filtersUse unique identifiers or strict filters
No projection in findOnly return needed fields
Ignoring atomicityRemember: each operation is atomic per document
No error handlingAlways check results and handle errors

8. Optional: Programmer’s Workflow Checklist​

  • Validate input before insert/update.

  • Use projections in queries to limit returned fields.

  • Test update/delete filters with find before running.

  • Use unique identifiers for critical updates/deletes.

  • Handle errors and check operation results.